{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 图像标题与LSTMs\n",
    "在前面的练习中，您实现了一个普通的RNN并将其应用于图像字幕。在这个笔记本中，您将实现LSTM更新规则并将其用于图像标题。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T12:02:05.606868Z",
     "start_time": "2020-02-25T12:02:05.531213Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The autoreload extension is already loaded. To reload it, use:\n",
      "  %reload_ext autoreload\n"
     ]
    }
   ],
   "source": [
    "# As usual, a bit of setup\n",
    "from __future__ import print_function\n",
    "import time, os, json\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from cs231n.gradient_check import eval_numerical_gradient, eval_numerical_gradient_array\n",
    "from cs231n.rnn_layers import *\n",
    "from cs231n.captioning_solver import CaptioningSolver\n",
    "from cs231n.classifiers.rnn import CaptioningRNN\n",
    "from cs231n.coco_utils import load_coco_data, sample_coco_minibatch, decode_captions\n",
    "from cs231n.image_utils import image_from_url\n",
    "\n",
    "%matplotlib inline\n",
    "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n",
    "plt.rcParams['image.interpolation'] = 'nearest'\n",
    "plt.rcParams['image.cmap'] = 'gray'\n",
    "\n",
    "# for auto-reloading external modules\n",
    "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n",
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "\n",
    "def rel_error(x, y):\n",
    "    \"\"\" returns relative error \"\"\"\n",
    "    return np.max(np.abs(x - y) / (np.maximum(1e-8, np.abs(x) + np.abs(y))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 加载MS-COCO数据\n",
    "和之前的笔记本一样，我们将使用Microsoft COCO数据集进行字幕。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T12:02:08.437855Z",
     "start_time": "2020-02-25T12:02:08.059903Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train_captions <class 'numpy.ndarray'> (400135, 17) int32\n",
      "train_image_idxs <class 'numpy.ndarray'> (400135,) int32\n",
      "val_captions <class 'numpy.ndarray'> (195954, 17) int32\n",
      "val_image_idxs <class 'numpy.ndarray'> (195954,) int32\n",
      "train_features <class 'numpy.ndarray'> (82783, 512) float32\n",
      "val_features <class 'numpy.ndarray'> (40504, 512) float32\n",
      "idx_to_word <class 'list'> 1004\n",
      "word_to_idx <class 'dict'> 1004\n",
      "train_urls <class 'numpy.ndarray'> (82783,) <U63\n",
      "val_urls <class 'numpy.ndarray'> (40504,) <U63\n"
     ]
    }
   ],
   "source": [
    "# Load COCO data from disk; this returns a dictionary\n",
    "# We'll work with dimensionality-reduced features for this notebook, but feel\n",
    "# free to experiment with the original features by changing the flag below.\n",
    "data = load_coco_data(pca_features=True)\n",
    "\n",
    "# Print out all the keys and values from the data dictionary\n",
    "for k, v in data.items():\n",
    "    if type(v) == np.ndarray:\n",
    "        print(k, type(v), v.shape, v.dtype)\n",
    "    else:\n",
    "        print(k, type(v), len(v))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# LSTM\n",
    "如果你读了最近的论文，你会发现很多人使用vanialla RNN的一个变种，叫做长短时记忆(LSTM) RNNs。由于重复矩阵乘法导致的梯度消失和爆炸，普通的rns很难在长序列上训练。LSTMs解决了这个问题，它用如下的门控机制替换了普通RNN的简单更新规则。\n",
    "\n",
    "Similar to the vanilla RNN, at each timestep we receive an input $x_t\\in\\mathbb{R}^D$ and the previous hidden state $h_{t-1}\\in\\mathbb{R}^H$; the LSTM also maintains an $H$-dimensional *cell state*, so we also receive the previous cell state $c_{t-1}\\in\\mathbb{R}^H$. The learnable parameters of the LSTM are an *input-to-hidden* matrix $W_x\\in\\mathbb{R}^{4H\\times D}$, a *hidden-to-hidden* matrix $W_h\\in\\mathbb{R}^{4H\\times H}$ and a *bias vector* $b\\in\\mathbb{R}^{4H}$.\n",
    "\n",
    "At each timestep we first compute an *activation vector* $a\\in\\mathbb{R}^{4H}$ as $a=W_xx_t + W_hh_{t-1}+b$. We then divide this into four vectors $a_i,a_f,a_o,a_g\\in\\mathbb{R}^H$ where $a_i$ consists of the first $H$ elements of $a$, $a_f$ is the next $H$ elements of $a$, etc. We then compute the *input gate* $g\\in\\mathbb{R}^H$, *forget gate* $f\\in\\mathbb{R}^H$, *output gate* $o\\in\\mathbb{R}^H$ and *block input* $g\\in\\mathbb{R}^H$ as\n",
    "\n",
    "$$\n",
    "\\begin{align*}\n",
    "i = \\sigma(a_i) \\hspace{2pc}\n",
    "f = \\sigma(a_f) \\hspace{2pc}\n",
    "o = \\sigma(a_o) \\hspace{2pc}\n",
    "g = \\tanh(a_g)\n",
    "\\end{align*}\n",
    "$$\n",
    "\n",
    "where $\\sigma$ is the sigmoid function and $\\tanh$ is the hyperbolic tangent, both applied elementwise.\n",
    "\n",
    "Finally we compute the next cell state $c_t$ and next hidden state $h_t$ as\n",
    "\n",
    "$$\n",
    "c_{t} = f\\odot c_{t-1} + i\\odot g \\hspace{4pc}\n",
    "h_t = o\\odot\\tanh(c_t)\n",
    "$$\n",
    "\n",
    "where $\\odot$ is the elementwise product of vectors.\n",
    "\n",
    "In the rest of the notebook we will implement the LSTM update rule and apply it to the image captioning task. \n",
    "\n",
    "In the code, we assume that data is stored in batches so that $X_t \\in \\mathbb{R}^{N\\times D}$, and will work with *transposed* versions of the parameters: $W_x \\in \\mathbb{R}^{D \\times 4H}$, $W_h \\in \\mathbb{R}^{H\\times 4H}$ so that activations $A \\in \\mathbb{R}^{N\\times 4H}$ can be computed efficiently as $A = X_t W_x + H_{t-1} W_h$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# LSTM: 单步前向\n",
    "在文件“cs231n/rnn_layers.py”中的“lstm_step_forward”函数中为LSTM的单个时间步长实现前向传播。这应该类似于您在上面实现的' rnn_step_forward '函数，但是使用的是LSTM更新规则。\n",
    "完成之后，运行以下代码来执行对实现的简单测试。您应该看到“1e-8”或以下的错误。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T12:02:14.021428Z",
     "start_time": "2020-02-25T12:02:13.946007Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "next_h error:  5.7054131185818695e-09\n",
      "next_c error:  5.8143123088804145e-09\n"
     ]
    }
   ],
   "source": [
    "N, D, H = 3, 4, 5\n",
    "x = np.linspace(-0.4, 1.2, num=N*D).reshape(N, D)\n",
    "prev_h = np.linspace(-0.3, 0.7, num=N*H).reshape(N, H)\n",
    "prev_c = np.linspace(-0.4, 0.9, num=N*H).reshape(N, H)\n",
    "Wx = np.linspace(-2.1, 1.3, num=4*D*H).reshape(D, 4 * H)\n",
    "Wh = np.linspace(-0.7, 2.2, num=4*H*H).reshape(H, 4 * H)\n",
    "b = np.linspace(0.3, 0.7, num=4*H)\n",
    "\n",
    "next_h, next_c, cache = lstm_step_forward(x, prev_h, prev_c, Wx, Wh, b)\n",
    "\n",
    "expected_next_h = np.asarray([\n",
    "    [ 0.24635157,  0.28610883,  0.32240467,  0.35525807,  0.38474904],\n",
    "    [ 0.49223563,  0.55611431,  0.61507696,  0.66844003,  0.7159181 ],\n",
    "    [ 0.56735664,  0.66310127,  0.74419266,  0.80889665,  0.858299  ]])\n",
    "expected_next_c = np.asarray([\n",
    "    [ 0.32986176,  0.39145139,  0.451556,    0.51014116,  0.56717407],\n",
    "    [ 0.66382255,  0.76674007,  0.87195994,  0.97902709,  1.08751345],\n",
    "    [ 0.74192008,  0.90592151,  1.07717006,  1.25120233,  1.42395676]])\n",
    "\n",
    "print('next_h error: ', rel_error(expected_next_h, next_h))\n",
    "print('next_c error: ', rel_error(expected_next_c, next_c))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# LSTM: 单步反向\n",
    "在文件“cs231n/rnn_layers.py”中的函数“lstm_step_back”中为单个LSTM时间步长实现向后传递。完成后，运行以下命令对实现执行数值梯度检查。您应该看到“1e-6”或以下的错误。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T12:03:00.856956Z",
     "start_time": "2020-02-25T12:03:00.636079Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dx error:  6.141176401368906e-10\n",
      "dh error:  3.3953235055372503e-10\n",
      "dc error:  1.5221723979041107e-10\n",
      "dWx error:  1.6933643922734908e-09\n",
      "dWh error:  2.5561308517943814e-08\n",
      "db error:  1.7349247160222088e-10\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "\n",
    "N, D, H = 4, 5, 6\n",
    "x = np.random.randn(N, D)\n",
    "prev_h = np.random.randn(N, H)\n",
    "prev_c = np.random.randn(N, H)\n",
    "Wx = np.random.randn(D, 4 * H)\n",
    "Wh = np.random.randn(H, 4 * H)\n",
    "b = np.random.randn(4 * H)\n",
    "\n",
    "next_h, next_c, cache = lstm_step_forward(x, prev_h, prev_c, Wx, Wh, b)\n",
    "\n",
    "dnext_h = np.random.randn(*next_h.shape)\n",
    "dnext_c = np.random.randn(*next_c.shape)\n",
    "\n",
    "fx_h = lambda x: lstm_step_forward(x, prev_h, prev_c, Wx, Wh, b)[0]\n",
    "fh_h = lambda h: lstm_step_forward(x, prev_h, prev_c, Wx, Wh, b)[0]\n",
    "fc_h = lambda c: lstm_step_forward(x, prev_h, prev_c, Wx, Wh, b)[0]\n",
    "fWx_h = lambda Wx: lstm_step_forward(x, prev_h, prev_c, Wx, Wh, b)[0]\n",
    "fWh_h = lambda Wh: lstm_step_forward(x, prev_h, prev_c, Wx, Wh, b)[0]\n",
    "fb_h = lambda b: lstm_step_forward(x, prev_h, prev_c, Wx, Wh, b)[0]\n",
    "\n",
    "fx_c = lambda x: lstm_step_forward(x, prev_h, prev_c, Wx, Wh, b)[1]\n",
    "fh_c = lambda h: lstm_step_forward(x, prev_h, prev_c, Wx, Wh, b)[1]\n",
    "fc_c = lambda c: lstm_step_forward(x, prev_h, prev_c, Wx, Wh, b)[1]\n",
    "fWx_c = lambda Wx: lstm_step_forward(x, prev_h, prev_c, Wx, Wh, b)[1]\n",
    "fWh_c = lambda Wh: lstm_step_forward(x, prev_h, prev_c, Wx, Wh, b)[1]\n",
    "fb_c = lambda b: lstm_step_forward(x, prev_h, prev_c, Wx, Wh, b)[1]\n",
    "\n",
    "num_grad = eval_numerical_gradient_array\n",
    "\n",
    "dx_num = num_grad(fx_h, x, dnext_h) + num_grad(fx_c, x, dnext_c)\n",
    "dh_num = num_grad(fh_h, prev_h, dnext_h) + num_grad(fh_c, prev_h, dnext_c)\n",
    "dc_num = num_grad(fc_h, prev_c, dnext_h) + num_grad(fc_c, prev_c, dnext_c)\n",
    "dWx_num = num_grad(fWx_h, Wx, dnext_h) + num_grad(fWx_c, Wx, dnext_c)\n",
    "dWh_num = num_grad(fWh_h, Wh, dnext_h) + num_grad(fWh_c, Wh, dnext_c)\n",
    "db_num = num_grad(fb_h, b, dnext_h) + num_grad(fb_c, b, dnext_c)\n",
    "\n",
    "dx, dh, dc, dWx, dWh, db = lstm_step_backward(dnext_h, dnext_c, cache)\n",
    "\n",
    "print('dx error: ', rel_error(dx_num, dx))\n",
    "print('dh error: ', rel_error(dh_num, dh))\n",
    "print('dc error: ', rel_error(dc_num, dc))\n",
    "print('dWx error: ', rel_error(dWx_num, dWx))\n",
    "print('dWh error: ', rel_error(dWh_num, dWh))\n",
    "print('db error: ', rel_error(db_num, db))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# LSTM: 前向\n",
    "在函数' lstm_forward '在文件' cs231n/rnn_layers。实现' lstm_forward '函数，在整个数据timeseries上运行LSTM forward。\n",
    "完成后，运行以下代码来检查实现。你应该会看到一个关于“1e-7”的错误。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T12:11:22.212915Z",
     "start_time": "2020-02-25T12:11:22.150617Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "h error:  8.610537452106624e-08\n"
     ]
    }
   ],
   "source": [
    "N, D, H, T = 2, 5, 4, 3\n",
    "x = np.linspace(-0.4, 0.6, num=N*T*D).reshape(N, T, D)\n",
    "h0 = np.linspace(-0.4, 0.8, num=N*H).reshape(N, H)\n",
    "Wx = np.linspace(-0.2, 0.9, num=4*D*H).reshape(D, 4 * H)\n",
    "Wh = np.linspace(-0.3, 0.6, num=4*H*H).reshape(H, 4 * H)\n",
    "b = np.linspace(0.2, 0.7, num=4*H)\n",
    "\n",
    "h, cache = lstm_forward(x, h0, Wx, Wh, b)\n",
    "\n",
    "expected_h = np.asarray([\n",
    " [[ 0.01764008,  0.01823233,  0.01882671,  0.0194232 ],\n",
    "  [ 0.11287491,  0.12146228,  0.13018446,  0.13902939],\n",
    "  [ 0.31358768,  0.33338627,  0.35304453,  0.37250975]],\n",
    " [[ 0.45767879,  0.4761092,   0.4936887,   0.51041945],\n",
    "  [ 0.6704845,   0.69350089,  0.71486014,  0.7346449 ],\n",
    "  [ 0.81733511,  0.83677871,  0.85403753,  0.86935314]]])\n",
    "\n",
    "print('h error: ', rel_error(expected_h, h))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# LSTM: 反向\n",
    "在文件“cs231n/rnn_layers.py”中的函数“lstm_back”中对整个数据timeseries执行LSTM的向后传递。完成后，运行以下命令对实现执行数值梯度检查。您应该看到“1e-7”或以下的错误。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T12:22:08.187837Z",
     "start_time": "2020-02-25T12:22:07.408160Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dx error:  4.82504980953228e-09\n",
      "dh0 error:  7.500898788574784e-09\n",
      "dWx error:  1.751994908422919e-09\n",
      "dWh error:  1.085376964509146e-06\n",
      "db error:  7.427550110055494e-10\n"
     ]
    }
   ],
   "source": [
    "from cs231n.rnn_layers import lstm_forward, lstm_backward\n",
    "np.random.seed(231)\n",
    "\n",
    "N, D, T, H = 2, 3, 10, 6\n",
    "\n",
    "x = np.random.randn(N, T, D)\n",
    "h0 = np.random.randn(N, H)\n",
    "Wx = np.random.randn(D, 4 * H)\n",
    "Wh = np.random.randn(H, 4 * H)\n",
    "b = np.random.randn(4 * H)\n",
    "\n",
    "out, cache = lstm_forward(x, h0, Wx, Wh, b)\n",
    "\n",
    "dout = np.random.randn(*out.shape)\n",
    "\n",
    "dx, dh0, dWx, dWh, db = lstm_backward(dout, cache)\n",
    "\n",
    "fx = lambda x: lstm_forward(x, h0, Wx, Wh, b)[0]\n",
    "fh0 = lambda h0: lstm_forward(x, h0, Wx, Wh, b)[0]\n",
    "fWx = lambda Wx: lstm_forward(x, h0, Wx, Wh, b)[0]\n",
    "fWh = lambda Wh: lstm_forward(x, h0, Wx, Wh, b)[0]\n",
    "fb = lambda b: lstm_forward(x, h0, Wx, Wh, b)[0]\n",
    "\n",
    "dx_num = eval_numerical_gradient_array(fx, x, dout)\n",
    "dh0_num = eval_numerical_gradient_array(fh0, h0, dout)\n",
    "dWx_num = eval_numerical_gradient_array(fWx, Wx, dout)\n",
    "dWh_num = eval_numerical_gradient_array(fWh, Wh, dout)\n",
    "db_num = eval_numerical_gradient_array(fb, b, dout)\n",
    "\n",
    "print('dx error: ', rel_error(dx_num, dx))\n",
    "print('dh0 error: ', rel_error(dh0_num, dh0))\n",
    "print('dWx error: ', rel_error(dWx_num, dWx))\n",
    "print('dWh error: ', rel_error(dWh_num, dWh))\n",
    "print('db error: ', rel_error(db_num, db))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# LSTM captioning model\n",
    "现在您已经实现了一个LSTM，更新文件' cs231n/classifiers/rnn '中的' CaptioningRNN '类的' loss '方法的实现。来处理“自我”的情况。cell_type’是‘lstm’。这应该需要添加少于10行的代码。\n",
    "完成之后，运行以下代码检查实现。你会看到一个小于“1e-10”的差值。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T12:23:19.656059Z",
     "start_time": "2020-02-25T12:23:19.584663Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss:  9.82445935443226\n",
      "expected loss:  9.82445935443\n",
      "difference:  2.261302256556519e-12\n"
     ]
    }
   ],
   "source": [
    "N, D, W, H = 10, 20, 30, 40\n",
    "word_to_idx = {'<NULL>': 0, 'cat': 2, 'dog': 3}\n",
    "V = len(word_to_idx)\n",
    "T = 13\n",
    "\n",
    "model = CaptioningRNN(word_to_idx,\n",
    "          input_dim=D,\n",
    "          wordvec_dim=W,\n",
    "          hidden_dim=H,\n",
    "          cell_type='lstm',\n",
    "          dtype=np.float64)\n",
    "\n",
    "# Set all model parameters to fixed values\n",
    "for k, v in model.params.items():\n",
    "  model.params[k] = np.linspace(-1.4, 1.3, num=v.size).reshape(*v.shape)\n",
    "\n",
    "features = np.linspace(-0.5, 1.7, num=N*D).reshape(N, D)\n",
    "captions = (np.arange(N * T) % V).reshape(N, T)\n",
    "\n",
    "loss, grads = model.loss(features, captions)\n",
    "expected_loss = 9.82445935443\n",
    "\n",
    "print('loss: ', loss)\n",
    "print('expected loss: ', expected_loss)\n",
    "print('difference: ', abs(loss - expected_loss))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Overfit LSTM captioning model\n",
    "运行下面的代码，在与前面的RNN相同的小数据集上对LSTM字幕模型进行过度拟合。损失应该小于0.5。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T12:25:06.574807Z",
     "start_time": "2020-02-25T12:23:45.007002Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 1 / 100) loss: 79.551150\n",
      "(Iteration 11 / 100) loss: 43.829099\n",
      "(Iteration 21 / 100) loss: 30.062610\n",
      "(Iteration 31 / 100) loss: 14.020070\n",
      "(Iteration 41 / 100) loss: 6.005386\n",
      "(Iteration 51 / 100) loss: 1.849711\n",
      "(Iteration 61 / 100) loss: 0.642087\n",
      "(Iteration 71 / 100) loss: 0.282384\n",
      "(Iteration 81 / 100) loss: 0.236188\n",
      "(Iteration 91 / 100) loss: 0.130116\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "\n",
    "small_data = load_coco_data(max_train=50)\n",
    "\n",
    "small_lstm_model = CaptioningRNN(\n",
    "          cell_type='lstm',\n",
    "          word_to_idx=data['word_to_idx'],\n",
    "          input_dim=data['train_features'].shape[1],\n",
    "          hidden_dim=512,\n",
    "          wordvec_dim=256,\n",
    "          dtype=np.float32,\n",
    "        )\n",
    "\n",
    "small_lstm_solver = CaptioningSolver(small_lstm_model, small_data,\n",
    "           update_rule='adam',\n",
    "           num_epochs=50,\n",
    "           batch_size=25,\n",
    "           optim_config={\n",
    "             'learning_rate': 5e-3,\n",
    "           },\n",
    "           lr_decay=0.995,\n",
    "           verbose=True, print_every=10,\n",
    "         )\n",
    "\n",
    "small_lstm_solver.train()\n",
    "\n",
    "# Plot the training losses\n",
    "plt.plot(small_lstm_solver.loss_history)\n",
    "plt.xlabel('Iteration')\n",
    "plt.ylabel('Loss')\n",
    "plt.title('Training loss history')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# LSTM test-time sampling\n",
    "修改在`CaptioningRNN`类中的`sample`方法去处理 `self.cell_type` 是 `lstm`的情况. 这应该只会用大概10行代码\n",
    "完成后，从您的overfit LSTM模型中对一些训练集和验证集样本运行以下示例。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T12:30:17.541972Z",
     "start_time": "2020-02-25T12:30:16.497634Z"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "http://farm9.staticflickr.com/8175/8042929905_dbb7a3f616_z.jpg\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "http://farm5.staticflickr.com/4134/4876982491_5359f44020_z.jpg\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "http://farm9.staticflickr.com/8318/8002651749_32511b0831_z.jpg\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "http://farm3.staticflickr.com/2605/3881233964_1808ff0a40_z.jpg\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "for split in ['train', 'val']:\n",
    "    minibatch = sample_coco_minibatch(small_data, split=split, batch_size=2)\n",
    "    gt_captions, features, urls = minibatch\n",
    "    gt_captions = decode_captions(gt_captions, data['idx_to_word'])\n",
    "\n",
    "    sample_captions = small_lstm_model.sample(features)\n",
    "    sample_captions = decode_captions(sample_captions, data['idx_to_word'])\n",
    "\n",
    "    for gt_caption, sample_caption, url in zip(gt_captions, sample_captions, urls):\n",
    "#         plt.imshow(image_from_url(url))\n",
    "        print(url)\n",
    "        plt.title('%s\\n%s\\nGT:%s' % (split, sample_caption, gt_caption))\n",
    "        plt.axis('off')\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 额外学分:培训一个良好的字幕模式!\n",
    "在对验证集抽样时，使用您在本例和前一篇笔记中实现的片段，尝试训练一个字幕模型，该模型可以提供适当的定性结果(比您在overfit模型中看到的随机垃圾更好)。我们只想看到验证集上的样本比随机的好。\n",
    "除了通过检查结果对模型进行定性评估外，还可以使用BLEU unigram精度度量对模型进行定量评估。如果你能训练出一个能达到>0.3的BLEU unigram评分的模型，我们会给你一小笔额外的学分。BLEU分数范围从0到1;越接近1越好。如果您有兴趣了解更多关于BLEU的工作原理，可以参考[论文](http://www.aclweb.org/anthology/P02-1040.pdf)。\n",
    "如果你想在GPU上训练得更快，可以使用PyTorch或TensorFlow。不过，您可以使用Numpy代码获得高于0.3的结果。我们提供给您的评估代码是与Numpy模型兼容，如上述定义…你应该能够适应它的TensorFlow/PyTorch，如果你走那条路线。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T12:34:48.663626Z",
     "start_time": "2020-02-25T12:34:47.691822Z"
    }
   },
   "outputs": [],
   "source": [
    "import nltk\n",
    "def BLEU_score(gt_caption, sample_caption):\n",
    "    \"\"\"\n",
    "    gt_caption: string, ground-truth caption\n",
    "    sample_caption: string, your model's predicted caption\n",
    "    Returns unigram BLEU score.\n",
    "    \"\"\"\n",
    "    reference = [x for x in gt_caption.split(' ') \n",
    "                 if ('<END>' not in x and '<START>' not in x and '<UNK>' not in x)]\n",
    "    hypothesis = [x for x in sample_caption.split(' ') \n",
    "                  if ('<END>' not in x and '<START>' not in x and '<UNK>' not in x)]\n",
    "    BLEUscore = nltk.translate.bleu_score.sentence_bleu([reference], hypothesis, weights = [1])\n",
    "    return BLEUscore\n",
    "\n",
    "def evaluate_model(model):\n",
    "    \"\"\"\n",
    "    model: CaptioningRNN model\n",
    "    Prints unigram BLEU score averaged over 1000 training and val examples.\n",
    "    \"\"\"\n",
    "    BLEUscores = {}\n",
    "    for split in ['train', 'val']:\n",
    "        minibatch = sample_coco_minibatch(small_data, split=split, batch_size=1000)\n",
    "        gt_captions, features, urls = minibatch\n",
    "        gt_captions = decode_captions(gt_captions, data['idx_to_word'])\n",
    "\n",
    "        sample_captions = model.sample(features)\n",
    "        sample_captions = decode_captions(sample_captions, data['idx_to_word'])\n",
    "\n",
    "        total_score = 0.0\n",
    "        for gt_caption, sample_caption, url in zip(gt_captions, sample_captions, urls):\n",
    "            try:\n",
    "                total_score += BLEU_score(gt_caption, sample_caption)\n",
    "            except (IOError ,ZeroDivisionError) as x:\n",
    "                print (x)\n",
    "\n",
    "        BLEUscores[split] = total_score / len(sample_captions)\n",
    "\n",
    "    for split in BLEUscores:\n",
    "        print('Average BLEU score for %s: %f' % (split, BLEUscores[split]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-25T12:35:06.867778Z",
     "start_time": "2020-02-25T12:34:51.696368Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Average BLEU score for train: 0.403101\n",
      "Average BLEU score for val: 0.130487\n"
     ]
    }
   ],
   "source": [
    "evaluate_model(small_lstm_model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  },
  "nbTranslate": {
   "displayLangs": [
    "*"
   ],
   "hotkey": "alt-t",
   "langInMainMenu": true,
   "sourceLang": "en",
   "targetLang": "fr",
   "useGoogleTranslate": true
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
